"use strict";
/*
function Person(name){
    this.name = name;
    this.run = function(){
        console.log(this.name)
    }
}
var p = new Person('张三')
p.run()
*/
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
/*
    ts中定义类
    class Person{
    name:string;//属性  前面省略public关键词

    constructor(n:string){//构造函数  实例化的时候触发的方法
        this.name = n;
    }
    run():void{
        alert(this.name)
    }
}
var p = new Person('张三');
p.run()


class Person{
    name:string;//属性  前面省略public关键词

    constructor(name:string){//构造函数  实例化的时候触发的方法
        this.name = name;
    }
    getName():string{
        return this.name
    }
    setName(name:string):void{
        this.name = name
    }

}
var p = new Person('张三');
alert(p.getName())
p.setName('zhouhangfeng')
alert(p.getName())
*/
// 2.ts中实现继承  extends / super
// class Person{
//     name:string;
//     constructor(name:string){
//         this.name = name
//     }
//     run():string{
//         return `${this.name}在运动`
//     }
// }
// // var p = new Person('王五')
// // alert(p.run())
// class Web extends Person{
//     constructor(name:string){
//         super(name); /*初始化父类的构造函数*/
//     }
// }
// var w = new Web('李四')
// alert(w.run())
// 2.ts中继承的探讨  父类的方法和子类的方法一致  去子类方法
// class Person{
//     name:string;
//     constructor(name:string){
//         this.name = name
//     }
//     run():string{
//         return `${this.name}在运动`
//     }
// }
// // var p = new Person('王五')
// // alert(p.run())
// class Web extends Person{
//     constructor(name:string){
//         super(name); /*初始化父类的构造函数*/
//     }
//     run():string{
//         return `${this.name}在运动-子类`
//     }
//     work():void{
//         alert(`${this.name}在运动`)
//     }
// }
// var w = new Web('李四')
// alert(w.run())
// // w.work();
// 3.类里面的修饰符  typescript里面定义属性的时候给我们提供了 三种修饰符
/*
    public：公有 在当前类里面 子类、类外面都可以访问
    protected：保护类型  在类里面、子类里面可以访问，在类外部没法访问
    private：私有  在类里面可以访问，子类，类外部都没法访问

    属性如果不加修饰符  默认就是公有
*/
// class Person{
//     public name:string;/*公有属性*/
//     constructor(name:string){
//         this.name = name
//     }
//     run():string{
//         return `${this.name}在运动`
//     }
// }
// // var p = new Person('王五')
// // alert(p.run())
// class Web extends Person{
//     constructor(name:string){
//         super(name); /*初始化父类的构造函数*/
//     }
//     run():string{
//         return `${this.name}在运动-子类`
//     }
//     work():void{
//         alert(`${this.name}在运动`)
//     }
// }
// var w = new Web('李四')
// // alert(w.run())
// w.work();
// 在类外部访问公有属性
// public
// class Person{
//     public name:string;/*公有属性*/
//     constructor(name:string){
//         this.name = name
//     }
//     run():string{
//         return `${this.name}在运动`
//     }
// }
// var p = new Person('哈哈哈');
// alert(p.name)
// protected
// class Person{
//     protected name:string;/*保护类型*/
//     constructor(name:string){
//         this.name = name
//     }
//     run():string{
//         return `${this.name}在运动`
//     }
// }
// // var p = new Person('王五')
// // alert(p.run())
// class Web extends Person{
//     constructor(name:string){
//         super(name); /*初始化父类的构造函数*/
//     }
//     work():void{
//         alert(`${this.name}在工作`)
//     }
// }
// var w = new Web('李四111')
// w.work()
// alert(w.run())
// // 类外外部无法访问保护类型的属性
// // alert(w.name)
// private 私有
// class Person{
//     private name:string;/*公有属性*/
//     constructor(name:string){
//         this.name = name
//     }
//     run():string{
//         return `${this.name}在运动`
//     }
// }
// class Web extends Person{
//     constructor(name:string){
//         super(name)
//     }
//     work():void{
//         console.log(`${this.name}在工作`)
//     }
// }
// var p = new Person('哈哈哈')
// p.name
// 静态属性  静态方法
/*
function Person(){
    // 实例方法
    this.run1 = function(){

    }
}
Person.name = '哈哈哈';
Person.run2 = function(){//静态方法

}
var p = new Person();
Person.run2();//静态方法的调用
*/
// jq中有使用
/*
$.get静态方法   $(#id).css('color','red')实例方法
*/
// class Per{
//     public name:string;
//     public age:number=20;
//     // 静态属性
//     static sex = "男";
//     constructor(name:string){
//         this.name = name;
//     }
//     run():string{
//         return `${this.name}在运动`
//     }
//     work():void{
//         console.log(`${this.name}在工作`)
//     }
//     static print(){//静态方法  里面没法直接调用类里面的属性
//         // alert('print方法'+Per.age)
//         alert('print方法'+Per.sex)
//     }
// }
// 多态：父类定义一个方法不去实现，让继承它的子类去实现，每一个子类有不同的表现
// 多态属于继承
// class Animal{
//     name:string;
//     constructor(name:string){
//         this.name = name
//     }
//     eat(){  //具体吃什么，不知道，让具体吃什么，继承它的子类去实现，每一个子类的表现不一样
//         console.log('吃的方法')
//     }
// }
// class Dog extends Animal{
//     constructor(name:string){
//         super(name)
//     }
//     eat():string{
//         return `${this.name}吃粮食`
//     }
// }
// class Cat extends Animal{
//     constructor(name:string){
//         super(name)
//     }
//     eat():string{
//         return `${this.name}吃鱼`
//     }
// }
// typescript中的抽象类，它是提供其他类继承的基类，不能直接被实例化。
// 用abstract关键字定义抽象类和抽象方法。抽象类中的抽象方法不包含具体实现必须在派生类中实现
// abstract抽象方法只能放在抽象类里面
// 抽象类和抽象方法用来定义标准，标准：Animal这个类要求它的子类必须包含cat方法
var Animal = /** @class */ (function () {
    function Animal(name) {
        this.name = name;
    }
    return Animal;
}());
// var a = new Animal()  //错误的写法
var Dog = /** @class */ (function (_super) {
    __extends(Dog, _super);
    // 抽象类的子类必须实现抽象类里面的抽象方法
    function Dog(name) {
        return _super.call(this, name) || this;
    }
    Dog.prototype.eat = function () {
        console.log(this.name + "\u5403\u7CAE\u98DF");
    };
    return Dog;
}(Animal));
var d = new Dog('小花');
d.eat();
